home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 351-375 / 351 / pdc / pdcsrc.lzh / PDC / GenFloat.c < prev    next >
C/C++ Source or Header  |  1990-04-06  |  17KB  |  714 lines
  1.  
  2. /* PDC Compiler - A Freely Distributable C Compiler for the Amiga
  3.  *                Based upon prior work by Matthew Brandt and Jeff Lydiatt.
  4.  *
  5.  * PDC Compiler release 3.3 Copyright (C) 1989 Paul Petersen and Lionel Hummel.
  6.  * PDC Software Distribution (C) 1989 Lionel Hummel and Paul Petersen.
  7.  *
  8.  * This code is freely redistributable upon the conditions that this 
  9.  * notice remains intact and that modified versions of this file not be 
  10.  * distributed as part of the PDC Software Distribution without the express
  11.  * consent of the copyright holders.
  12.  *
  13.  *------------------------------------------------------------------
  14.  *
  15.  * $Log:    GenFloat.c,v $
  16.  * Revision 3.33  90/04/05  22:33:46  lionel
  17.  * Changed library function callouts to prevent collisions with user functions
  18.  * 
  19.  * Revision 3.32  90/02/03  16:24:13  lionel
  20.  * None
  21.  * 
  22.  *------------------------------------------------------------------
  23.  */
  24.  
  25. /*
  26.  * GenFloat.c
  27.  * 
  28.  * This module contains all of the code generation routines for evaluating
  29.  * floating-point expressions and conditions.
  30.  */
  31.  
  32. #include        <stdio.h>
  33. #include        "C.h"
  34. #include        "Expr.h"
  35. #include        "Gen.h"
  36. #include        "Cglbdec.h"
  37.  
  38. struct amode   *temp_data(), *temp_addr(), *makeareg(), *makedreg();
  39. struct amode   *copy_addr(), *temp_float();
  40. struct amode   *make_autocon(), *make_delta();
  41. struct enode   *makenode();
  42.  
  43. struct amode   *request_addr(), *request_data(), *request_float();
  44. struct amode   *request_reg();
  45.  
  46. struct amode   *gen_expr(); /* forward declaration */
  47. void            swap_nodes();   /* ditto */
  48.  
  49. extern int      avail_data(), avail_addr();
  50. extern struct amode *check_float();
  51.  
  52. extern struct amode push[], pop[];
  53.  
  54. struct amode   *
  55. gen_stabn(node, flags, size)
  56.  
  57. /*
  58.  * Generate the code for a op_stabn instruction
  59.  */
  60.     struct enode   *node;
  61.     int             flags, size;
  62. {
  63.     struct amode   *ap1, *ap2;
  64.  
  65.     if (node == NULL) {
  66.         fprintf( stderr, "DIAG -- null node in gen_stabn.\n" );
  67.         return NULL;
  68.     }
  69.  
  70.     ap1 = gen_expr(node->v.p[0], flags, size);
  71.     make_legal(ap1, flags, size);
  72.     ap2 = gen_expr(node->v.p[1], flags, size);
  73.     make_legal(ap2, flags, size);
  74.  
  75.     return ap1;
  76. }
  77.  
  78.  
  79. struct amode   *
  80. gen_stabs(node, flags, size)
  81.  
  82. /*
  83.  * Generate the code for a op_stabs instruction
  84.  */
  85.     struct enode   *node;
  86.     int             flags, size;
  87. {
  88.     struct amode   *ap1, *ap2;
  89.  
  90.     if (node == NULL) {
  91.         fprintf( stderr, "DIAG -- null node in gen_stabn.\n" );
  92.         return NULL;
  93.     }
  94.  
  95.     ap1 = gen_expr(node->v.p[0], flags, size);
  96.     make_legal(ap1, flags, size);
  97.     ap2 = gen_expr(node->v.p[1], flags, size);
  98.     make_legal(ap2, flags, size);
  99.  
  100.     return ap1;
  101. }
  102.  
  103. struct amode   *
  104. gen_fsconvert(node, flags, size)
  105.     struct enode   *node;
  106.     int             flags, size;
  107. {
  108.     struct amode   *ap1, *ap2, *ap3;
  109.  
  110.     flags = F_DREG;
  111.     size = 4;
  112.  
  113.     ap1 = gen_expr(node->v.p[0], flags, size);
  114.     make_legal(ap1, flags, size);
  115.  
  116.     validate(ap1);
  117.     if ((int) ap1->preg != 0) {
  118.         ap2 = request_data(0);
  119.         gen_code(op_move, 4, ap1, makedreg((enum e_am) 0));
  120.         freeop(ap2);
  121.     }
  122.     freeop(ap1);
  123.  
  124.     ap3 = request_addr(0);
  125.     freeop(ap3);
  126.  
  127.     switch (node->nodetype) {
  128.     case en_cld:
  129.         PdcFlags |= PDC_IEEEDOUBLE;
  130.         call_library(".Fl2d");
  131.         break;
  132.     case en_cfd:
  133.         PdcFlags |= PDC_IEEEDOUBLE | PDC_IEEESINGLE;
  134.         call_library(".Fs2d");
  135.         break;
  136.     case en_clf:
  137.         PdcFlags |= PDC_IEEESINGLE;
  138.         call_library(".Fl2s");
  139.         ap2 = temp_data();
  140.         if ((int)ap2->preg != 0)
  141.             gen_code( op_move, 4, makedreg(0), ap2 );
  142.         return (ap2);
  143.     case en_cfl:
  144.         PdcFlags |= PDC_IEEESINGLE;
  145.         call_library(".Fs2l");
  146.         ap2 = temp_data();
  147.         if ((int)ap2->preg != 0)
  148.             gen_code( op_move, 4, makedreg(0), ap2 );
  149.         return (ap2);
  150.  
  151.     }
  152.  
  153.     ap2 = temp_float();
  154.     return (ap2);
  155. }
  156.  
  157. struct amode   *
  158. gen_fconvert(node, flags, size)
  159.     struct enode   *node;
  160.     int             flags, size;
  161. {
  162.     struct amode   *ap1, *ap2;
  163.  
  164.     flags = F_FREG;
  165.     size = 8;
  166.  
  167.     ap1 = gen_expr(node->v.p[0], flags, size);
  168.     make_legal(ap1, flags, size);
  169.  
  170.     validate(ap1);
  171.  
  172.     freeop(ap1);
  173.  
  174.     switch (node->nodetype) {
  175.     case en_cdl:
  176.         PdcFlags |= PDC_IEEEDOUBLE;
  177.         call_library(".Fd2l");
  178.         break;
  179.     case en_cdf:
  180.         PdcFlags |= PDC_IEEEDOUBLE | PDC_IEEESINGLE;
  181.         call_library(".Fd2s");
  182.         break;
  183.     }
  184.  
  185.     ap2 = temp_data();
  186.  
  187.     if ((int) ap2->preg != 0)
  188.         gen_code(op_move, 4, makedreg((enum e_am) 0), ap2);
  189.  
  190.     return (ap2);
  191. }
  192.  
  193. struct amode   *
  194. gen_fsunary(node, flags, size, op)
  195.  
  196. /*
  197.  * generate code to evaluate a unary minus or complement.
  198.  */
  199.     struct enode   *node;
  200.     int             flags, size;
  201.     enum e_op       op;
  202. {
  203.     struct amode   *ap, *ap2;
  204.  
  205.     if (node == NULL) {
  206.         fprintf( stderr, "DIAG -- null node in gen_fsunary.\n" );
  207.         return NULL;
  208.     }
  209.  
  210.     flags = F_DREG;
  211.     ap = gen_expr(node->v.p[0], F_DREG, size);
  212.     make_legal(ap, flags, size);
  213.  
  214.     if ((int) ap->preg != 0) {
  215.         ap2 = request_data(0);
  216.         gen_code(op_move, 4, ap, makedreg((enum e_am) 0));
  217.         freeop(ap2);
  218.     }
  219.     freeop(ap);
  220.  
  221.     switch (op) {
  222.     case op_fneg:
  223.         PdcFlags |= PDC_IEEESINGLE;
  224.         call_library(".FSneg");
  225.         break;
  226.     default:
  227.         fprintf( stderr, "DIAG -- uncoded unary float operation\n" );
  228.         break;
  229.     }
  230.  
  231.     ap = temp_data();
  232.     if ((int) ap->preg != 0)
  233.         gen_code(op_move, 4, makedreg((enum e_am) 0), ap);
  234.  
  235.     return ap;
  236. }
  237.  
  238. struct amode   *
  239. gen_funary(node, flags, size, op)
  240.  
  241. /*
  242.  * generate code to evaluate a unary minus or complement.
  243.  */
  244.     struct enode   *node;
  245.     int             flags, size;
  246.     enum e_op       op;
  247. {
  248.     struct amode   *ap;
  249.  
  250.     if (node == NULL) {
  251.         fprintf( stderr, "DIAG -- null node in gen_funary.\n" );
  252.         return NULL;
  253.     }
  254.  
  255.     flags = F_FREG;
  256.  
  257.     ap = gen_expr(node->v.p[0], flags, size);
  258.     make_legal(ap, flags, size);
  259.  
  260.     switch (op) {
  261.     case op_fneg:
  262.         PdcFlags |= PDC_IEEEDOUBLE;
  263.         call_library(".FDneg");
  264.         break;
  265.     default:
  266.         fprintf( stderr, "DIAG -- uncoded unary float operation\n" );
  267.         break;
  268.     }
  269.  
  270.     return ap;
  271. }
  272.  
  273. struct amode   *
  274. gen_fsbinary(node, flags, size, op)
  275.  
  276. /*
  277.  * generate code to evaluate a binary node and return the addressing mode of
  278.  * the result.
  279.  */
  280.     struct enode   *node;
  281.     int             flags, size;
  282.     enum e_op       op;
  283. {
  284.     struct amode   *ap1, *ap2, *ap3;
  285.  
  286.     if (node == NULL) {
  287.         fprintf( stderr, "DIAG -- null node in gen_fsbinary.\n" );
  288.         return NULL;
  289.     }
  290.  
  291.     flags = F_DREG;
  292.  
  293.     ap1 = gen_expr(node->v.p[0], flags, size);
  294.     make_legal(ap1, flags, size);
  295.     ap2 = gen_expr(node->v.p[1], flags, size);
  296.     make_legal(ap2, flags, size);
  297.  
  298.     validate(ap2);
  299.     validate(ap1);
  300.  
  301.     if (op == op_fadd || op == op_fmul) {
  302.         if ((int) ap1->preg == 0) {
  303.             if ((int) ap2->preg != 1) {
  304.                 ap3 = request_data(1);
  305.                 gen_code(op_move, 4, ap2, ap3);
  306.                 freeop(ap3);
  307.             }
  308.         }
  309.         else if ((int) ap1->preg == 1) {
  310.             if ((int) ap2->preg != 0) {
  311.                 ap3 = request_data(0);
  312.                 gen_code(op_move, 4, ap2, ap3);
  313.                 freeop(ap3);
  314.             }
  315.         }
  316.         else {
  317.             if ((int) ap2->preg == 0) {
  318.                 ap3 = request_data(1);
  319.                 gen_code(op_move, 4, ap1, ap3);
  320.                 freeop(ap3);
  321.             }
  322.             else if ((int) ap2->preg == 1) {
  323.                 ap3 = request_data(0);
  324.                 gen_code(op_move, 4, ap1, ap3);
  325.                 freeop(ap3);
  326.             }
  327.         }
  328.     }
  329.     else {
  330.         if ((int) ap1->preg == 0) {
  331.             if ((int) ap2->preg != 1) {
  332.                 ap3 = request_data(1);
  333.                 gen_code(op_move, 4, ap2, ap3);
  334.                 freeop(ap3);
  335.             }
  336.         }
  337.         else if ((int) ap2->preg == 1) {
  338.             ap3 = request_data(0);
  339.             gen_code(op_move, 4, ap1, ap3);
  340.             freeop(ap3);
  341.         }
  342.         else {
  343.             if ((int) ap1->preg == 1) {
  344.                 if ((int) ap2->preg == 0)
  345.                     gen_code(op_exg, 4, ap1, ap2);
  346.                 else {
  347.                     ap3 = request_data(0);
  348.                     gen_code(op_move, 4, ap1, ap3);
  349.                     gen_code(op_move, 4, ap2, ap1);
  350.                     freeop(ap3);
  351.                 }
  352.             }
  353.             else if ((int) ap2->preg == 0) {
  354.                 ap3 = request_data(1);
  355.                 gen_code(op_move, 4, ap2, ap3);
  356.                 gen_code(op_move, 4, ap1, ap2);
  357.                 freeop(ap3);
  358.             }
  359.         }
  360.     }
  361.  
  362.     freeop(ap2);
  363.     freeop(ap1);
  364.  
  365.     switch (op) {
  366.     case op_fadd:
  367.         PdcFlags |= PDC_IEEESINGLE;
  368.         call_library(".FSadd");
  369.         break;
  370.     case op_fsub:
  371.         PdcFlags |= PDC_IEEESINGLE;
  372.         call_library(".FSsub");
  373.         break;
  374.     case op_fmul:
  375.         PdcFlags |= PDC_IEEESINGLE;
  376.         call_library(".FSmul");
  377.         break;
  378.     case op_fdiv:
  379.         PdcFlags |= PDC_IEEESINGLE;
  380.         call_library(".FSdiv");
  381.         break;
  382.     case op_fmod:
  383.         PdcFlags |= PDC_IEEESINGLE;
  384.         call_library(".FSmod");
  385.         break;
  386.     default:
  387.         fprintf( stderr, "DIAG -- uncoded binary floating operation\n" );
  388.         break;
  389.     }
  390.  
  391.     ap1 = temp_data();
  392.  
  393.     if ((int) ap1->preg != 0)
  394.         gen_code(op_move, size, makedreg((enum e_am) 0), ap1);
  395.  
  396.     return ap1;
  397. }
  398.  
  399. struct amode   *
  400. gen_fbinary(node, flags, size, op)
  401.  
  402. /*
  403.  * generate code to evaluate a binary node and return the addressing mode of
  404.  * the result.
  405.  */
  406.     struct enode   *node;
  407.     int             flags, size;
  408.     enum e_op       op;
  409. {
  410.     int             used;
  411.     struct amode   *ap1, *ap2;
  412.  
  413.     if (node == NULL) {
  414.         fprintf( stderr, "DIAG -- null node in gen_fbinary.\n" );
  415.         return NULL;
  416.     }
  417.  
  418.     flags = F_MEM | F_IMMED;
  419.     size = 8;
  420.  
  421.     if (node->v.p[1]->nodetype == en_d_ref) {
  422.         ap2 = gen_expr(node->v.p[1], flags, 4);
  423.         make_legal(ap2, flags, 4);
  424.     }
  425.     else {
  426.         ap2 = gen_expr(node->v.p[1], F_FREG, 8);
  427.         make_legal(ap2, F_FREG, size);
  428.     }
  429.  
  430.     if (node->v.p[0]->nodetype == en_d_ref) {
  431.         ap1 = gen_expr(node->v.p[0], flags, 4);
  432.         make_legal(ap1, flags, 4);
  433.     }
  434.     else {
  435.         ap1 = gen_expr(node->v.p[0], F_FREG, 8);
  436.         make_legal(ap1, F_FREG, size);
  437.     }
  438.  
  439.  
  440.     if (ap1 == NULL || ap2 == NULL)
  441.         return( NULL );
  442.  
  443.     /* ---------------------------------------------------- */
  444.  
  445.     if (ap1->mode == am_freg) { /* ap1 in D0:D1                 */
  446.         if (ap2->mode == am_freg) { /* ap2 in D0:D1                 */
  447.             validate(ap1);
  448.             ap2 = check_float(ap2);
  449.         }
  450.         else {      /* ap2 as mem reference         */
  451.             make_legal(ap1, F_FREG, 8);
  452.             validate(ap2);
  453.         }
  454.     }
  455.     else {          /* ap1 as mem reference         */
  456.         if (ap2->mode == am_freg) { /* ap2 in D0:D1                 */
  457.             validate(ap1);
  458.             make_legal(ap1, F_FREG, 8);
  459.             ap2 = check_float(ap2);
  460.         }
  461.         else {      /* ap2 as mem refernece         */
  462.             make_legal(ap1, F_FREG, 8);
  463.             validate(ap2);
  464.         }
  465.     }
  466.  
  467.     used = FALSE;
  468.     if ((ap2->mode != am_areg && ap2->mode != am_indx) ||
  469.         (int) ap2->preg != 0) {
  470.         if (used = (!avail_addr(0)))
  471.             gen_code(op_move, 4, makeareg((enum e_am) 0), push);
  472.         gen_code(op_lea, 0, ap2, makeareg((enum e_am) 0));
  473.     }
  474.  
  475.     freeop(ap1);
  476.     freeop(ap2);
  477.  
  478.     switch (op) {
  479.     case op_fadd:
  480.         PdcFlags |= PDC_IEEEDOUBLE;
  481.         call_library(".FDadd");
  482.         break;
  483.     case op_fmul:
  484.         PdcFlags |= PDC_IEEEDOUBLE;
  485.         call_library(".FDmul");
  486.         break;
  487.     case op_fsub:
  488.         PdcFlags |= PDC_IEEEDOUBLE;
  489.         call_library(".FDsub");
  490.         break;
  491.     case op_fdiv:
  492.         PdcFlags |= PDC_IEEEDOUBLE;
  493.         call_library(".FDdiv");
  494.         break;
  495.     case op_fmod:
  496.         PdcFlags |= PDC_IEEEDOUBLE;
  497.         call_library(".FDmod");
  498.         break;
  499.     case op_cmp:
  500.         PdcFlags |= PDC_IEEEDOUBLE;
  501.         call_library(".FDcmp");
  502.         break;
  503.     default:
  504.         fprintf( stderr, "DIAG -- uncoded binary floating operation\n" );
  505.         break;
  506.     }
  507.  
  508.     if (used)
  509.         gen_code(op_move, 4, pop, makeareg((enum e_am) 0));
  510.  
  511.     ap1 = temp_float();
  512.  
  513.     return ap1;
  514. }
  515.  
  516. /*
  517.  * generate code to evaluate a binary node and return the addressing mode of
  518.  * the result.
  519.  */
  520.  
  521. struct amode   *
  522. gen_fsaincdec(node, flags, size, op)
  523.     struct enode   *node;
  524.     int             flags, size;
  525.     enum e_op       op;
  526. {
  527.     struct amode   *ap1, *ap2, *ap3;
  528.  
  529.     if (node == NULL) {
  530.         fprintf( stderr, "DIAG -- null node in gen_fsaincdec.\n" );
  531.         return NULL;
  532.     }
  533.  
  534.     flags = F_DREG;
  535.  
  536.     ap1 = gen_expr(node->v.p[0], flags, size);
  537.     make_legal(ap1, flags, size);
  538.     ap2 = gen_expr(node->v.p[1], flags, size);
  539.     make_legal(ap2, flags, size);
  540.  
  541.     validate(ap2);
  542.     validate(ap1);
  543.  
  544.     if (op == op_fadd) {
  545.         if ((int) ap1->preg == 0) {
  546.             if ((int) ap2->preg != 1) {
  547.                 ap3 = request_data(1);
  548.                 gen_code(op_move, 4, ap2, ap3);
  549.                 freeop(ap3);
  550.             }
  551.         }
  552.         else if ((int) ap1->preg == 1) {
  553.             if ((int) ap2->preg != 0) {
  554.                 ap3 = request_data(0);
  555.                 gen_code(op_move, 4, ap2, ap3);
  556.                 freeop(ap3);
  557.             }
  558.         }
  559.         else {
  560.             if ((int) ap2->preg == 0) {
  561.                 ap3 = request_data(1);
  562.                 gen_code(op_move, 4, ap1, ap3);
  563.                 freeop(ap3);
  564.             }
  565.             else if ((int) ap2->preg == 1) {
  566.                 ap3 = request_data(0);
  567.                 gen_code(op_move, 4, ap1, ap3);
  568.                 freeop(ap3);
  569.             }
  570.         }
  571.     }
  572.     else {
  573.         if ((int) ap1->preg == 0) {
  574.             if ((int) ap2->preg != 1) {
  575.                 ap3 = request_data(1);
  576.                 gen_code(op_move, 4, ap2, ap3);
  577.                 freeop(ap3);
  578.             }
  579.         }
  580.         else if ((int) ap2->preg == 1) {
  581.             ap3 = request_data(0);
  582.             gen_code(op_move, 4, ap1, ap3);
  583.             freeop(ap3);
  584.         }
  585.         else {
  586.             if ((int) ap1->preg == 1) {
  587.                 if ((int) ap2->preg == 0)
  588.                     gen_code(op_exg, 4, ap1, ap2);
  589.                 else {
  590.                     ap3 = request_data(0);
  591.                     gen_code(op_move, 4, ap1, ap3);
  592.                     gen_code(op_move, 4, ap2, ap1);
  593.                     freeop(ap3);
  594.                 }
  595.             }
  596.             else if ((int) ap2->preg == 0) {
  597.                 ap3 = request_data(1);
  598.                 gen_code(op_move, 4, ap2, ap3);
  599.                 gen_code(op_move, 4, ap1, ap2);
  600.                 freeop(ap3);
  601.             }
  602.         }
  603.     }
  604.  
  605.     freeop(ap2);
  606.     freeop(ap1);
  607.  
  608.     switch (op) {
  609.     case op_fadd:
  610.         PdcFlags |= PDC_IEEESINGLE;
  611.         call_library(".FSadd");
  612.         break;
  613.     case op_fsub:
  614.         PdcFlags |= PDC_IEEESINGLE;
  615.         call_library(".FSsub");
  616.         break;
  617.     default:
  618.         fprintf( stderr, "DIAG -- uncoded binary floating operation\n" );
  619.         break;
  620.     }
  621.  
  622.     ap1 = temp_data();
  623.  
  624.     if ((int) ap1->preg != 0)
  625.         gen_code(op_move, size, makedreg((enum e_am) 0), ap1);
  626.  
  627.     return ap1;
  628. }
  629.  
  630. struct amode   *
  631. gen_faincdec(node, flags, size, op)
  632.  
  633. /*
  634.  * generate code to evaluate a binary node and return the addressing mode of
  635.  * the result.
  636.  */
  637.     struct enode   *node;
  638.     int             flags, size;
  639.     enum e_op       op;
  640. {
  641.     int             used;
  642.     struct amode   *ap1, *ap2, *ap3;
  643.  
  644.     if (node == NULL) {
  645.         fprintf( stderr, "DIAG -- null node in gen_faincdec.\n" );
  646.         return NULL;
  647.     }
  648.  
  649.     flags = F_MEM | F_IMMED;
  650.     size = 8;
  651.  
  652.     ap2 = gen_expr(node->v.p[1], flags, 4);
  653.     make_legal(ap2, flags, 4);
  654.  
  655.     ap1 = gen_expr(node->v.p[0], flags, 4);
  656.     make_legal(ap1, flags, 4);
  657.  
  658.     if (ap1 == NULL || ap2 == NULL)
  659.         return( NULL );
  660.  
  661.     validate( ap1 );
  662.     validate( ap2 );
  663.  
  664.     ap3 = copy_addr( ap1 );
  665.  
  666.     make_legal(ap1, F_FREG, 8);
  667.     validate(ap2);
  668.  
  669.     gen_code(op_move, 4, makedreg((enum e_am) 0), push);
  670.     gen_code(op_move, 4, makedreg((enum e_am) 1), push);
  671.  
  672.     used = FALSE;
  673.     if ((ap2->mode != am_areg && ap2->mode != am_indx) ||
  674.         (int) ap2->preg != 0) {
  675.         if (used = (!avail_addr(0)))
  676.             gen_code(op_move, 4, makeareg((enum e_am) 0), push);
  677.         gen_code(op_lea, 0, ap2, makeareg((enum e_am) 0));
  678.     }
  679.  
  680.     freeop(ap1);
  681.     freeop(ap2);
  682.  
  683.     ap3 = request_reg( ap3 );
  684.  
  685.     switch (op) {
  686.     case op_fadd:
  687.         PdcFlags |= PDC_IEEEDOUBLE;
  688.         call_library(".FDadd");
  689.         break;
  690.     case op_fsub:
  691.         PdcFlags |= PDC_IEEEDOUBLE;
  692.         call_library(".FDsub");
  693.         break;
  694.     default:
  695.         fprintf( stderr, "DIAG -- uncoded binary floating operation\n" );
  696.         break;
  697.     }
  698.  
  699.     gen_code(op_move, 4, makedreg((enum e_am) 0), make_delta( ap3, 0));
  700.     gen_code(op_move, 4, makedreg((enum e_am) 1), make_delta( ap3, 4));
  701.  
  702.     freeop( ap3 );
  703.  
  704.     if (used)
  705.         gen_code(op_move, 4, pop, makeareg((enum e_am) 0));
  706.  
  707.     ap1 = temp_float();
  708.  
  709.     gen_code(op_move, 4, pop, makedreg((enum e_am) 1));
  710.     gen_code(op_move, 4, pop, makedreg((enum e_am) 0));
  711.  
  712.     return ap1;
  713. }
  714.